﻿#pragma once
#include <iostream>
#include <stack>
#include <vector>
#include <list>
using namespace std;
#include <queue>
#include <functional>



void test_stack()
{
	LYL::stack<int> st;

	st.top();

	st.push(1);
	st.push(2);
	st.push(3);
	st.push(4);

	while (!st.empty())
	{
		cout << st.top() << " ";
		st.pop();
	}
	cout << endl;
}

void test_priority_queue()
{
	// 仿函数/函数对象
	// 默认是大堆 -- 大的优先级高
	// priority_queue<int> pq;

	// 小堆 -- 小的优先级高
	priority_queue<int, vector<int>, greater<int>> pq;
	pq.push(1);
	pq.push(0);
	pq.push(5);
	pq.push(2);
	pq.push(1);
	pq.push(7);

	while (!pq.empty())
	{
		cout << pq.top() << " ";
		pq.pop();
	}
	cout << endl;
}

//struct Less
//{
//	bool operator()(int x, int y)
//	{
//		return x < y;
//	}
//};

template<class T>
struct Less
{
	bool operator()(const T& x, const T& y)
	{
		return x < y;
	}
};

int main()
{
	//test_stack();
	//bit::test_queue();
	//test_priority_queue();

	Less<int> lessFunc;
	cout << lessFunc(1, 2) << endl;

	void(*ptr1)();

	return 0;
}
namespace LYL
{
	// ģʽ/
	//template<class T, class Container = vector<T>>
	template<class T, class Container = deque<T>>
	class stack
	{
	public:
		void push(const T& x)
		{
			_con.push_back(x);
		}

		void pop()
		{
			_con.pop_back();
		}

		const T& top()
		{
			return _con.back();
		}

		size_t size()
		{
			return _con.size();
		}

		bool empty()
		{
			return _con.empty();
		}

	private:
		//vector<T> _v;
		Container _con;
	};

	//void test_stack()
	//{
	//	//stack<int, vector<int>> st;
	//	//stack<int, list<int>> st;
	//	stack<int> st;
	//	st.push(1);
	//	st.push(2);
	//	st.push(3);
	//	st.push(4);

	//	while (!st.empty())
	//	{
	//		cout << st.top() << " ";
	//		st.pop();
	//	}
	//	cout << endl;
	//}
}